tools »

02 - Numpy核心语法[1]

Table of Content

1. 基本数据结构¶

NumPy 的核心数据结构是 ndarray（即 n-dimensional array，多维数组）数据结构。这是一个多维度、同质并且大小固定的数组对象。

为了表达记录类型的数据，Numpy又拓展出名为Structured Array的数据结构。

它用一个 void 类型的元组来表示一条记录，从而使得 numpy 也可以用来表达记录型的数据。因此，在 Numpy 中，实际上跟数组有关的数据类型主要是两种。

1. 基本数据结构¶

前一种数组格式广为人知，我们将以它为例介绍多数 Numpy 操作。而后一种数据格式，在量化中也常常用到，比如，通过聚宽[1]的jqdatasdk获得的行情数据，就允许返回这种数据类型，与 DataFrame 相比，在存取上有不少简便之处。我们将在后面专门用一个章节来介绍。

在使用 Numpy 之前，我们要先安装和导入 Numpy 库：

# 安装 NUMPY
pip install numpy

一般地，我们通过别名np来导入和使用 numpy：

import numpy as np

为了在 Notebook 中运行这些示例时，能更加醒目地显示结果，我们首先定义一个 cprint 函数，它将原样输出提示信息，但对变量使用红色字体来输出，以示区别：

from termcolor import colored

def cprint(formatter: str, *args):
    colorful = [colored(f"{item}", 'red') for item in args]
    print(formatter.format(*colorful))

# 测试一下 CPRINT
cprint("这是提示信息，后接红色字体输出的变量值：{}", "hello!")

接下来，我们将介绍基本的增删改查操作。

1.1. 创建数组¶

1.1.1. 通过 Python List 创建¶

我们可以通过np.array的语法来创建一个简单的数组,在这个语法中，我们可以提供 Python 列表，或者任何具有 Iterable 接口的对象，比如元组。

arr = np.array([1, 2, 3])
cprint("create a simple numpy array: {}", arr)

1.1.2. 预置特殊数组¶

很多时候，我们希望 Numpy 为我们创建一些具有特殊值的数组。Numpy 也的确提供了这样的支持，比如：

函数	描述
zeros zeros_like	创建全 0 的数。zeros_like 接受另一个数组，并生成相同形状和数据类型的 zeros 数组。常用于初始化。以下*_like 类推。
ones ones_like	创建全 1 的数组
full full_like	创建一个所有元素都填充为`n`的数组
empty empty_like	创建一个空数组
eye identity	创建单位矩阵
random.random	创建一个随机数组
random.normal	创建一个符合正态分布的随机数组
random.dirichlet	创建一个符合狄利克雷分布的随机数组
arange	创建一个递增数组
linspace	创建一个线性增长数组。与 arange 的区别在于，此方法默认生成全闭区间数组。并且，它的元素之间的间隔可以为浮点数。

# 创建特殊类型的数组
cprint("全 0 数组：\n{}", np.zeros(3))
cprint("全 1 数组：\n{}", np.ones((2, 3)))
cprint("单位矩阵：\n{}", np.eye(3))
cprint("由数字 5 填充的矩阵：\n{}", np.full((3,2), 5))

cprint("空矩阵：\n{}", np.empty((2, 3)))
cprint("随机矩阵：\n{}",np.random.random(10))
cprint("正态分布的数组：\n{}",np.random.normal(10))
cprint("狄利克雷分布的数组：\n{}",np.random.dirichlet(np.ones(10)))
cprint("顺序增长的数组：\n{}", np.arange(10))
cprint("线性增长数组：\n{}", np.linspace(0, 2, 9))

Warning

尽管 empty 函数的名字暗示它应该生成一个空数组，但实际上生成的数组，每个元素都是有值的，只不过这些值既不是 np.nan，也不是 None，而是随机值。我们在使用 empty 生成的数组之前，一定要对它进行初始化，处理掉这些随机值。

生成正态分布数组很有用。我们在做一些研究时，常常需要生成满足某种条件的价格序列，再进一步研究和比较它的特性。

比如，如果我们想研究上升趋势和下降趋势下的某些指标，就需要有能力先构建出符合趋势的价格序列。下面的例子就演示了如何生成这样的序列，并且绘制图形：

import numpy as np
import matplotlib.pyplot as plt

returns = np.random.normal(0, 0.02, size=100)

fig, axes = plt.subplots(1, 3, figsize=(12,4))
c0 = np.random.randint(5, 50)

for i, alpha in enumerate((-0.01, 0, 0.01)):
    r = returns + alpha
    close = np.cumprod(1 + r) * c0
    axes[i].plot(close)

绘制的图形如下：

示例中还提到了 Dirichlet（狄利克雷）分布数组。这个数组具有这样的特点，它的所有元素加起来会等于 1。比如，在现代投资组合理论中的有效前沿优化中，我们首先需要初始化各个资产的权重（随机值），并且满足资产权重之和等于 1 的约束（显然！），此时我们就可以使用 Dirichlet[2] 分布。

1.1.3. 通过已有数组转换¶

我们还可以从已有的数组中，通过复制、切片、重复等方法，创建新的数组：

# 复制一个数组
cprint("通过 np.copy 创建：{}", np.copy(np.arange(5)))

# 复制数组的另一种方法
cprint("通过 arr.copy: {}", np.arange(5).copy())

# 使用切片，提取原数组的一部分
cprint("通过切片：{}", np.arange(5)[:2])

# 合并两个数组
arr = np.concatenate((np.arange(3), np.arange(2)))
cprint("通过 concatenate 合并：{}", arr)

# 重复一个数组
arr = np.repeat(np.arange(3), 2)
cprint("通过 repeat 重复原数组：{}", arr)

# 重复一个数组，注意与 NP.REPEAT 的差异
# NP.TILE 的语义类似于 PYTHON 的 LIST 乘法
arr = np.tile(np.arange(3), 2)
cprint("通过 tile 重复原数组：{}", arr)

Question

np.copy 与 arr.copy 有何不同？在 Numpy 中还有哪些类似函数对，有何规律？

注意在 concatenate 函数中，axis 的作用：

arr = np.arange(6).reshape((3,2))

# 在 ROW 方向上拼接，相当于增加行，默认行为
cprint("按 axis=0 拼接：\n{}", np.concatenate((arr, arr), axis=0))
# 在 COL 方向上拼接，相当于扩展列
cprint("按 axis=1 拼接：\n{}", np.concatenate((arr, arr), axis=1))

1.2. 增加/删除和修改元素¶

Numpy 数组是固定大小的，一般我们不推荐频繁地往数组中增加或者删除元素。

但如果确实有这种需求，我们可以使用下面的方法来实现增加或者删除：

函数	使用说明
append	将`values`添加到`arr`的末尾。
insert	向`obj`（可以是下标、slicing）指定的位置处，插入数值`value`（可以是标量，也可以是数组）
delete	删除指定下标处的元素

示例如下：

arr = np.arange(6).reshape((3,2))
np.append(arr, [[7,8]], axis=0)
cprint("指定在行的方向上操作、n{}", arr)

arr = np.arange(6).reshape((3,2))
arr = np.insert(arr.reshape((3,2)), 1, -10)
cprint("不指定 axis，数组被扁平化：\n{}", arr)

arr = np.arange(6).reshape((3,2))
arr = np.insert(arr, 1, (-10, -10), axis=0)
cprint("np.insert:\n{}", arr)

arr = np.delete(arr, [1], axis=1)
cprint("deleting col 1:\n{}", arr)

Tip

请一定运行一下这里的代码，特别是关于 insert 的部分，了解所谓的扁平化是怎么回事。

有时候我们需要修改个别元素的值，应该这样操作：

arr = np.arange(6).reshape(2,3)

arr[0,2] = 3

这里涉及到如何定位一个数组元素的问题，也正是我们下一节的内容。

1.3. 定位、读取和搜索¶

1.3.1. 索引和切片¶

Numpy 中索引和切片语法大致类似于 Python，主要区别在于对多维数组的支持：

arr = np.arange(6).reshape((3,2))
cprint("原始数组：\n{}", arr)

# 切片语法
cprint("按行切片：{}", arr[1, :])
cprint("按列切片：{}", arr[:, -1])
cprint("逆排数组：\n {}", arr[: : -1])

# FANCY INDEXING
cprint("fancy index: 使用下标数组：\n {}", arr[[2, 1, 0]])

上述切片语法在 Python 中也存在，但只能支持到一维，因此，对下面的 Python 数组，类似操作会出错：

arr = np.arange(6).reshape((3,2)).tolist()

arr[1, :]

提示 list indices must be integers or slices, not tuple。

1.3.2. 查找、筛选和替换¶

在上一节中，我们是通过索引来定位一个数组元素。但很多时候，我们得先通过条件运算把符合要求的索引找出来。这一节将介绍相关方法。

函数	使用说明
np.searchsorted	在有序数组中搜索指定的数值，返回索引。
np.nonzero	返回非零元素的索引，用以查找数组中满足条件的元素。
np.flatnonzero	同 nonzero，但返回输入数组的展平版本中非零的索引。
np.argwere	返回满足条件的元素的索引，相当于 nonzero 的转置版本
np.argmin	返回数组中最小元素的索引（注意不是返回满足条件的最小索引）
np.argmax	返回数组中最大元素的索引

# 查找
arr = [0, 2, 2, 2, 3]
pos = np.searchsorted(arr, 2, 'right')
cprint("在数组 {} 中寻找等于 2 的位置，返回 {}, 数值是 {}", 
        arr, pos, arr[pos - 1])

arr = np.arange(6).reshape((2, 3))
cprint("arr[arr > 1]: {}", arr[arr > 1])

# NONZERO 的用法
mask = np.nonzero(arr > 1)

cprint("nonzero 返回结果是：{}", mask)
cprint("筛选后的数组是：{}", arr[mask])

# ARGWHERE 的用法
mask = np.argwhere(arr > 1)
cprint("argwere 返回的结果是：{}", mask)

# 多维数组不能直接使用 ARGWHERE 结果来筛选
# 下面的语句不能得到正确结果，一般会出现 INDEXERROR
arr[mask]

# 但对一维数组筛选我们可以用：
arr = np.arange(6)
mask = np.argwhere(arr > 1)
arr[mask.flatten()[0]]

# 寻找最大值的索引
arr = [1, 2, 2, 1, 0]
cprint("最大值索引是：{}", np.argmax(arr))

使用 searchsorted 要注意，数组本身一定是有序的，不然不会得出正确结果。

第 10 行到第 21 行代码，显示了如何查找一个数组中符合条件的数据，并且返回它的索引。

argwhere 返回值相当于 nonzero 的转置，在多维数组的情况下，它不能直接用作数组的索引。请自行对比 nonzero 与 argwhere 的用法。

在量化中，有很多情况需要实现筛选功能。比如，在计算上下影线时，我们是用公式\((high - max(open, close))/(high - low)\)来进行计算的。

如果我们要一次性地计算过去 n 个周期的所有上影线，并且不使用循环的话，那么我们就要使用 np.where, np.select 等筛选功能。

下面的例子显示了如何使用 np.select 来计算上影线：

import pandas as pd
import numpy as np

bars = pd.DataFrame({
    "open": [10, 10.2, 10.1],
    "high": [11, 10.5, 9.3],
    "low": [9.8, 9.8, 9.25],
    "close": [10.1, 10.2, 10.05]
})

max_oc = np.select([bars.close > bars.open, 
                    bars.close <= bars.open], 
                    [bars.close, bars.open])
print(max_oc)

shadow = (bars.high - max_oc)/(bars.high - bars.low)
print(shadow)

np.where 是与 np.select 相近的一个函数，不过它只接受一个条件。

arr = np.arange(6)
cprint("np.where: {}", np.where(arr > 3, 3, arr))

这段代码实现了将 3 以上的数字截断为 3 的功能。

这种功能被称为 clip，在因子预处理中是非常常用的一个技巧，用来处理异常值 (outlier)。

但它没有办法实现两端截断。此时，但 np.select 能做到，这是 np.where 与 np.select 的主要区别：

arr = np.arange(6)
cprint("np.select: {}", np.select([arr<2, arr>4], [2, 4], arr))

其结果是，生成的数组，小于 2 的被替换成 2，大于 4 的被替换成 4，其它的保持不变。

1.4. 审视 (inspecting) 数组¶

当我们调用其它人的库时，往往需要与它们交换数据。这时就可能出现数据格式不兼容的问题。为了有能力进行查错，我们必须掌握查看 Numpy 数组特性的一些方法。

我们先如下生成一个简单的数组，再查看它的各种特性：

arr = np.ones((3,2))
cprint("dtype is: {}", arr.dtype)
cprint("shape is: {}", arr.shape)
cprint("ndim is: {}", arr.ndim)
cprint("size is: {}", arr.size)
cprint("'len' is also available: {}", len(arr))

# DTYPE
dt = np.dtype('>i4')
cprint("byteorder is: {}", dt.byteorder)
cprint("name of the type is: {}", dt.name)
cprint('is ">i4" a np.int32?: {}', dt.type is np.int32)

# 复杂的 DTYPE
complex = np.dtype([('name', 'U8'), ('score', 'f4')])
arr = np.array([('Aaron', 85), ('Zoe', 90)], dtype=complex)
cprint("A structured Array: {}", arr)
cprint("Dtype of structured array: {}", arr.dtype)

正如 Python 对象都有自己的数据类型一样，Numpy 数组也有自己的数据类型。我们可以通过arr.dtype来查看数组的数据类型。

从第 3 行到第 6 行，我们分别输出了数组的 shape, ndim, size 和 len 等属性。ndim 告诉我们数组的维度。shape 告诉我们每个维度的 size 是多少。shape 本身是一个 tuple, 这个 tuple 的 size，也等于 ndim。

size 在不带参数时，返回的是 shape 各元素取值的乘积。len 返回的是第一维的长度。

2. 数组操作¶

我们在前面的例子中，已经看到过一些引起数组形状改变的例子。比如，要生成一个\(3×2\)的数组，我们先用 np.arange(6) 来生成一个一维数组，再将它的形状改变为 (2, 3)。

另一个例子是使用 np.concatenate，从而改变了数组的行或者列。

2.1. 升维¶

我们可以通过 reshape, hstack, vstack 来改变数组的维度：

cprint("increase ndim with reshape:\n{}", 
        np.arange(6).reshape((3,2)))

# 将两个一维数组，堆叠为 2*3 的二维数组
cprint("createing from stack: {}", 
        np.vstack((np.arange(3), np.arange(4,7))))

# 将两个 （3，1）数组，堆叠为（3，2）数组
np.hstack((np.array([[1],[2],[3]]), np.array([[4], [5], [6]])))

2.2. 降维¶

通过 ravel, flatten, reshape, *split 等操作对数组进行降维。

cprint("ravel: {}", arr.ravel())

cprint("flatten: {}", arr.flatten())

# RESHAPE 也可以用做扁平化
cprint("flatten by reshape: {}", arr.reshape(-1,))

# 使用 HSPLIT, VSPLIT 进行降维
x = np.arange(6).reshape((3, 2))
cprint("split:\n{}", np.hsplit(x, 2))

# RAVEL 与 FLATTEN 的区别：RAVEL 可以操作 PYTHON 的 LIST
np.ravel([[1,2,3],[4, 5, 6]])

这里一共介绍了 4 种方法。ravel 与 flatten 用法比较接近。ravel 的行为与 flatten 类似，只不过 ravel 是 np 的一个函数，可作用于 ArrayLike 的数组。

通过 reshape 来进行扁平化也是常用操作。此外，还介绍了 vsplit, hsplit 函数，它们的作用刚好与 vstack，hstack 相反。

2.3. 转置¶

此外，对数组进行转置也是此类例子中的一个。比如，在前面我们提到，np.argwhere 的结果，实际上是 np.nonzero 的转置，我们来验证一下：

x = np.arange(6).reshape(2,3)
cprint("argwhere: {}", np.argwhere(x > 1))

# 我们再来看 NP.NONZERO 的转置
cprint("nonzero: {}", np.array(np.nonzero(x > 1)).T)

两次输出结果完全一样。在这里，我们是通过.T来实现的转置，它是一个语法糖，正式的函数是transpose。

当然，由于 reshape 函数极其强大，我们也可以使用它来完成转置：

cprint("transposing array from \n{} to \n{}", 
    np.arange(6).reshape((2,3)),
    np.arange(6).reshape((3,2)))

狄利克雷，德国数学家。他对数论、傅里叶级数理论和其他数学分析学领域有杰出贡献，并被认为是最早给出现代函数定义的数学家之一和解析数论创始人之一。Dirichlet 数组可作为 MPT 求解中的初始值。